#!/usr/bin/env node

/**
 * 步骤1：发现新的未国际化内容并生成key
 * 
 * 功能：
 * 1. 扫描项目中的中文文本
 * 2. 对比已有的语言包，找出尚未国际化的新内容
 * 3. 为新内容生成合适的key
 * 4. 输出待处理的内容清单
 */

const fs = require('fs');
const path = require('path');
const crypto = require('crypto');

class I18nDiscoverer {
  constructor() {
    this.projectRoot = path.resolve(__dirname, '../');
    this.i18nPath = path.join(this.projectRoot, 'src/i18n/config');
    this.srcPath = path.join(this.projectRoot, 'src');
    
    
    this.chineseRegex = /[\u4e00-\u9fa5][\u4e00-\u9fa5\s\.,，。！？；：()（）""\''']*[\u4e00-\u9fa5]/g;
    this.singleChineseRegex = /[\u4e00-\u9fa5]/g;
    
    this.fileExtensions = ['.vue', '.js', '.ts'];
    this.excludeDirs = ['node_modules', '.git', 'dist', 'build', 'i18n', 'uni_modules'];
    
    // 已有的国际化内容（从语言包中读取）
    this.existingContent = new Set();
    
    // 项目中发现的所有中文内容
    this.foundContent = new Map(); // content -> locations[]
    
    // 新发现的需要国际化的内容
    this.newContent = new Map(); // content -> {key, locations[]}
    
    console.log('🔍 步骤1：发现新的未国际化内容');
    console.log(`📁 项目根目录: ${this.projectRoot}`);
  }

  /**
   * 加载已有的国际化内容
   */
  loadExistingContent() {
    console.log('\n📚 加载已有的国际化内容...');
    
    try {
      const zhPath = path.join(this.i18nPath, 'zh');
      this.loadLanguageFiles(zhPath);
      
      console.log(`✅ 已加载 ${this.existingContent.size} 个已国际化的内容`);
      
      if (this.existingContent.size > 0) {
        console.log('📋 已有内容示例:');
        let count = 0;
        for (const content of this.existingContent) {
          if (count < 5) {
            console.log(`   "${content}"`);
            count++;
          }
        }
        if (this.existingContent.size > 5) {
          console.log(`   ... 还有 ${this.existingContent.size - 5} 个`);
        }
      }
    } catch (error) {
      console.warn('⚠️ 加载已有内容时出错:', error.message);
      console.log('📝 将创建全新的国际化映射');
    }
  }

  /**
   * 递归加载语言文件中的内容
   */
  loadLanguageFiles(dirPath) {
    if (!fs.existsSync(dirPath)) return;
    
    const files = fs.readdirSync(dirPath);
    files.forEach(file => {
      const filePath = path.join(dirPath, file);
      const stat = fs.statSync(filePath);
      
      if (stat.isDirectory()) {
        this.loadLanguageFiles(filePath);
      } else if (file.endsWith('.js')) {
        try {
          const fileContent = fs.readFileSync(filePath, 'utf8');
          
          // 解析export default后的对象
          if (fileContent.includes('export default')) {
            const match = fileContent.match(/export\s+default\s+(\{[\s\S]*\})/);
            if (match) {
              try {
                // 简单解析对象
                const objStr = match[1]
                  .replace(/([{,]\s*)(\w+):/g, '$1"$2":') // 给属性名添加引号
                  .replace(/'/g, '"'); // 统一使用双引号
                
                const obj = JSON.parse(objStr);
                this.extractValuesFromObject(obj);
              } catch (parseError) {
                // 解析失败，跳过这个文件
              }
            }
          }
        } catch (error) {
          // 读取失败，跳过
        }
      }
    });
  }

  /**
   * 从对象中提取所有的中文值
   */
  extractValuesFromObject(obj) {
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        if (typeof obj[key] === 'object' && obj[key] !== null) {
          this.extractValuesFromObject(obj[key]);
        } else if (typeof obj[key] === 'string' && this.isChineseText(obj[key])) {
          this.existingContent.add(obj[key]);
        }
      }
    }
  }

  /**
   * 检查是否是中文文本
   */
  isChineseText(text) {
    return /[\u4e00-\u9fa5]/.test(text);
  }

  /**
   * 扫描项目中的所有中文内容
   */
  scanProjectContent() {
    console.log('\n🔍 扫描项目中的中文内容...');
    this.scanDirectory(this.srcPath);
    console.log(`📊 项目中发现 ${this.foundContent.size} 个中文内容`);
  }

  scanDirectory(dirPath) {
    try {
      const files = fs.readdirSync(dirPath);
      
      files.forEach(file => {
        const filePath = path.join(dirPath, file);
        const stat = fs.statSync(filePath);
        
        if (stat.isDirectory()) {
          if (!this.excludeDirs.includes(file)) {
            this.scanDirectory(filePath);
          }
        } else {
          const ext = path.extname(file);
          if (this.fileExtensions.includes(ext)) {
            this.scanFile(filePath);
          }
        }
      });
    } catch (error) {
      console.warn(`⚠️ 扫描目录 ${dirPath} 失败:`, error.message);
    }
  }

  scanFile(filePath) {
    try {
      const content = fs.readFileSync(filePath, 'utf8');
      const lines = content.split('\n');
      
      for (let i = 0; i < lines.length; i++) {
        const line = lines[i];
        if (!line.trim()) continue;
        
        // 提取这一行的中文内容
        const chineseTexts = this.extractChineseFromLine(line);
        
        chineseTexts.forEach(text => {
          if (!this.foundContent.has(text)) {
            this.foundContent.set(text, []);
          }
          
          this.foundContent.get(text).push({
            file: filePath,
            line: i + 1,
            content: line.trim()
          });
        });
      }
    } catch (error) {
      console.warn(`⚠️ 无法读取文件 ${filePath}:`, error.message);
    }
  }

  /**
   * 从一行代码中提取中文文本
   */
  extractChineseFromLine(line) {
    const results = new Set();
    
    // 跳过注释和console语句
    if (this.isCommentLine(line) || this.isConsoleStatement(line)) {
      return results;
    }
    
    // 跳过已经国际化的行
    if (line.includes('$t(') || line.includes('this.$t(')) {
      return results;
    }
    
    // 提取多字符中文文本
    const multiCharMatches = line.match(this.chineseRegex);
    if (multiCharMatches) {
      multiCharMatches.forEach(match => {
        const cleanMatch = this.cleanChineseText(match);
        if (cleanMatch && this.shouldInclude(line, cleanMatch)) {
          results.add(cleanMatch);
        }
      });
    }
    
    // 提取单个中文字符（在引号内）
    const singleCharMatches = line.match(this.singleChineseRegex);
    if (singleCharMatches) {
      singleCharMatches.forEach(char => {
        if (this.isSingleChineseInQuotes(line, char) && 
            this.shouldInclude(line, char)) {
          results.add(char);
        }
      });
    }
    
    return results;
  }

  /**
   * 清理中文文本
   */
  cleanChineseText(text) {
    return text.trim().replace(/^[，。！？；：（）【】""\'''、\s]+|[，。！？；：（）【】""\'''、\s]+$/g, '');
  }

  /**
   * 判断是否应该包含这个中文文本
   */
  shouldInclude(line, chineseText) {
    const cleanText = this.cleanChineseText(chineseText);
    
    if (!cleanText || cleanText.length === 0) return false;
    if (!/[\u4e00-\u9fa5]/.test(cleanText)) return false;
    
    // 跳过技术术语
    const technicalTerms = ['vue', 'js', 'css', 'html', 'json', 'md', 'scss', 'ts'];
    if (technicalTerms.includes(cleanText.toLowerCase())) return false;
    
    // 跳过URL和路径
    if (line.includes('http') || line.includes('://') || 
        line.includes('/static/') || line.includes('./')) return false;
    
    // 跳过import/export语句
    if (line.includes('import') || line.includes('require(') || 
        line.includes('export') || line.includes('from ')) return false;
    
    // 单个字符需要在引号内
    if (cleanText.length === 1) {
      return this.isSingleChineseInQuotes(line, cleanText);
    }
    
    return cleanText.length >= 1;
  }

  isSingleChineseInQuotes(line, chineseChar) {
    const charIndex = line.indexOf(chineseChar);
    if (charIndex === -1) return false;
    
    const quotes = ['"', "'", '`'];
    for (const quote of quotes) {
      const quoteBefore = line.lastIndexOf(quote, charIndex);
      const quoteAfter = line.indexOf(quote, charIndex + 1);
      if (quoteBefore !== -1 && quoteAfter !== -1) return true;
    }
    
    return false;
  }

  isCommentLine(line) {
    const trimmed = line.trim();
    return trimmed.startsWith('//') || trimmed.startsWith('*') || 
           trimmed.startsWith('/*') || trimmed.startsWith('<!--') ||
           trimmed.includes('<!--') || trimmed.includes('-->');
  }

  isConsoleStatement(line) {
    return line.includes('console.') || line.includes('console[');
  }

  /**
   * 找出新的未国际化内容
   */
  findNewContent() {
    console.log('\n🆕 对比找出新的未国际化内容...');
    
    let newCount = 0;
    for (const [content, locations] of this.foundContent) {
      if (!this.existingContent.has(content)) {
        const key = this.generateKey(content);
        this.newContent.set(content, {
          key: key,
          locations: locations
        });
        newCount++;
      }
    }
    
    console.log(`🎯 发现 ${newCount} 个新的未国际化内容`);
    
    if (newCount > 0) {
      console.log('\n📋 新内容示例:');
      let count = 0;
      for (const [content, info] of this.newContent) {
        if (count < 10) {
          console.log(`   "${content}" -> ${info.key} (在 ${info.locations.length} 个位置)`);
          count++;
        }
      }
      if (newCount > 10) {
        console.log(`   ... 还有 ${newCount - 10} 个`);
      }
    }
  }

  /**
   * 为内容生成合适的key
   */
  generateKey(content) {
    // 常见词汇的固定映射
    const commonWords = {
      '确认': 'confirm',
      '取消': 'cancel',
      '提交': 'submit',
      '保存': 'save',
      '删除': 'delete',
      '编辑': 'edit',
      '添加': 'add',
      '新增': 'add',
      '搜索': 'search',
      '查询': 'query',
      '登录': 'login',
      '注册': 'register',
      '退出': 'logout',
      '首页': 'home',
      '我的': 'mine',
      '个人中心': 'profile',
      '设置': 'settings',
      '返回': 'back',
      '下一步': 'next',
      '上一步': 'previous',
      '完成': 'complete',
      '失败': 'failed',
      '成功': 'success',
      '错误': 'error',
      '警告': 'warning',
      '信息': 'info',
      '提示': 'tip',
      '加载中': 'loading',
      '无数据': 'noData',
      '暂无数据': 'noData',
      '网络错误': 'networkError',
      '操作成功': 'operateSuccess',
      '操作失败': 'operateFailed',
      '马拉松': 'marathon',
      '比赛': 'race',
      '赛事': 'event',
      '参赛者': 'participant',
      '成绩': 'result',
      '证书': 'certificate',
      '排名': 'ranking',
      '时间': 'time',
      '地点': 'location',
      '详情': 'detail',
      '报名': 'signup',
      '列表': 'list',
      '全部': 'all',
      '筛选': 'filter',
      '暂无': 'none',
      '未知': 'unknown',
      '开始': 'start',
      '结束': 'end',
      '进行中': 'inProgress',
      '已结束': 'finished'
    };

    // 检查是否有直接映射
    if (commonWords[content]) {
      return this.ensureUniqueKey(commonWords[content]);
    }

    // 根据内容特征生成key
    const cleanContent = this.cleanChineseText(content);
    let prefix = '';
    
    if (cleanContent.length === 1) {
      prefix = 'char';
    } else if (cleanContent.length <= 3) {
      prefix = 'text';
    } else if (cleanContent.length <= 8) {
      prefix = 'msg';
    } else if (cleanContent.includes('？') || cleanContent.includes('吗')) {
      prefix = 'question';
    } else if (cleanContent.includes('！') || cleanContent.includes('成功') || cleanContent.includes('失败')) {
      prefix = 'status';
    } else {
      prefix = 'desc';
    }
    
    // 使用内容的hash作为唯一标识
    const hash = crypto.createHash('md5').update(content).digest('hex').substring(0, 8);
    const baseKey = `${prefix}_${hash}`;
    
    return this.ensureUniqueKey(baseKey);
  }

  /**
   * 确保key的唯一性
   */
  ensureUniqueKey(baseKey) {
    const usedKeys = new Set();
    
    // 收集已经使用的key
    for (const [content, info] of this.newContent) {
      usedKeys.add(info.key);
    }
    
    let uniqueKey = baseKey;
    let counter = 1;
    while (usedKeys.has(uniqueKey)) {
      uniqueKey = `${baseKey}_${counter}`;
      counter++;
    }
    
    return uniqueKey;
  }


  /**
   * 生成报告
   */
  generateReport() {
    console.log('\n📊 发现报告:');
    console.log('='.repeat(60));
    console.log(`📁 扫描目录: ${this.srcPath}`);
    console.log(`📚 已有国际化内容: ${this.existingContent.size} 个`);
    console.log(`🔍 项目中发现内容: ${this.foundContent.size} 个`);
    console.log(`🆕 新的未国际化内容: ${this.newContent.size} 个`);
    console.log('='.repeat(60));
    
    if (this.newContent.size === 0) {
      console.log('\n🎉 所有内容都已国际化！');
    } else {
      console.log('\n💡 下一步：');
      console.log('   运行 node scripts/step2-translate.js 进行翻译');
    }
  }

  /**
   * 主运行方法
   */
  run() {
    try {
      // 1. 加载已有的国际化内容
      this.loadExistingContent();
      
      // 2. 扫描项目中的中文内容
      this.scanProjectContent();
      
      // 3. 找出新的未国际化内容
      this.findNewContent();
      
      // 4. 生成报告
      this.generateReport();
      
      console.log('\n🎉 步骤1完成！');
      
    } catch (error) {
      console.error('❌ 步骤1失败:', error);
      process.exit(1);
    }
  }
}

// 运行脚本
if (require.main === module) {
  const discoverer = new I18nDiscoverer();
  discoverer.run();
}

module.exports = I18nDiscoverer;